\documentclass[a4paper,11pt,oneside]{article}
\usepackage{latexsym}
\usepackage[latin1]{inputenc}
\usepackage[italian]{babel}
\usepackage{amsfonts,amssymb,epsfig,amsmath,amsthm}
\usepackage{graphics,subfigure}
\usepackage{makeidx}
\usepackage{hyperref}


\title{Progetto Battaglia Navale\\Classi e Funzionamento}
\author{Paolo Pigato\\Davide Poletti}

\begin{document}

\maketitle

Il programma che descriviamo usa il linguaggio C++ e la programmazione a oggetti per gestire una partita a battaglia navale.  L'impostazione delle opzioni avviene direttamente dal main. Entrambi i giocatori possono essere sia umani che ?computer?, si pu\'o decidere la dimensione della plancia di gioco e in caso di giocatore computer si pu\'o scegliere tra tre diversi livelli di intelligenza della strategia. Si entra nella parte "a oggetti" vera e propria solo quando si sceglie di avviare una partita.

\section{Il Game Manager}
Un oggetto di questa classe viene creato dinamicamente al momento di iniziare una partita. Possiede i metodi: {inizializza\_partita}, che ha il compito di inizializzare gli oggetti necessari secondo le opzioni scelte nel main; {turno}, che si occupa di gestire un turno di gioco; {partita}, che chiama inizializza\_partita, decide di chi \'e il turno di gioco e invoca turno, stabilisce la fine della partita e comunica il vincitore.

\section{Giocatore}
\'E una classe astratta da cui ereditano GiocatoreUmano e GiocatoreComputer. Ogni giocatore possiede due mari, {\_mare\_mio} e  {\_mare\_avv}, una lista delle proprie navi {\_navi\_mie}, e due navi fittizie {\_nave\_colpite} e {\_nave\_affondate}, che vengono usate per farvi puntare le caselle "colpite" e quelle "affondate". Questo deriva dal fatto che nella nostra implementazione la presenza di una nave su una casella \'e segnalata da un puntatore dalla casella alla nave stessa.
Nella classe astratta sono implementati i metodi che non differiscono tra Umano e Computer: {subisci\_sparo}, che comunica al proprio mare le coordinate del colpo avversario e ne restituisce l'esito; {aggiorna\_con\_esito}, che aggiorna la propria "copia" del mare avversario con l'esito restituito; {affonda\_nave}, che in caso di esito "affondata" affonda tutte le caselle "colpite" circostanti. I metodi {posiziona\_nave} e {spara} sono invece virtuali e implementati diversamente nelle classi che ereditano. 

\subsection{GiocatoreUmano}
I metodi {spara} e {posiziona\_nave} sono implementati tramite l'uso della libreria di classi $<$iostream$>$, che permette all'utente di interagire con il programma, e di alcuni metodi ausiliari.

\subsection{GiocatoreComputer}
Il metodo {posiziona\_nave} posiziona in modo casuale una nave (della dimensione desiderata se passata come argomento, di dimensione casuale altrimenti), rispettando le regole del gioco. GiocatoreComputer possiede come attributo anche un puntatore a un oggetto Strategia, il cui metodo {spara} viene invocato da {spara} del giocatore, quando si tratta di scegliere le coordinate della casella a cui sparare.
        
\section{Strategia}
\'E una classe astratta il cui compito \'e decidere le coordinate dello sparo per il giocatore, fornite dal metodo {spara} che prende come argomento \_mare\_avv. Durante l'inizializzazione del gioco l'utente pu\'o scegliere tre diversi livelli di "bravura" per il giocatore computer, a cui corrispondono tre diverse classi derivate da Strategia

\subsection{StrategiaRandom}
Questa strategia spara in modo casuale in \_mare\_avv, evitando solamente di sparare su caselle dove ha gi\'a sparato.

\subsection{StrategiaFurba}
Questa strategia spara in modo casuale in \_mare\_avv, e quando una casella restituisce "colpita" spara nelle caselle adiacenti fino a capire l'orientamento della nave. Poi spara seguendo quell'orientamento fino a che la nave non viene affondata.

\subsection{StrategiaFurba}
Si comporta come strategia furba, ma quando spara in modo casuale alla ricerca di una nave evita di sparare nelle caselle adiacenti a una nave gi\'a colpita, poich\'e non \'e possibile che li ci sia un'altra nave.

\section{Mare}
L' attributo principale della classe mare \'e un vector di vector di caselle. C'\'e poi un bool che identifica l'oggetto mare come mare proprio o immagine che il giocatore possiede del mare dell'avversario. I metodi ci\_sta\_nave e inserisci\_nave vengono utilizzati nella fase di inizializzazione della partita per l'inserimento delle navi, mentre subisci\_sparo aggiorna il mare dopo la ricezione di un colpo e comunica l'esito di questo colpo. Questo metodo viene utilizzato sia in subisci\_sparo che in aggiorna\_con\_esito di Giocatore. Ci sono poi alcuni metodi ausiliari: test\_casella verifica la possibilit\'a di inserire una nave in una casella di date coordinate, e viene utilizzato sia nella fase di inserimento delle navi che nella StrategiaPiuFurba. vai\_successiva e l'operatore [] vengono utilizzati per chiamare in causa le caselle necessarie nelle varie fasi di gioco, e l'operatore di output $<<$ del mare utilizza l'analogo $<<$ della classe casella per la stampa del mare.

\section{Nave}
\'E una classe astratta con attributi \_posizione e \_orientamento, una variabile booleana \_affondata ed una variabile intera \_colpita. I metodi che possiede servono solamente a ritornarne o modificarne gli attributi. Da questa classe ereditano Nave1, ..., Nave5, che rappresentano i tipi di nave che un giocatore pu\'o inserire nel proprio mare, e la classe Nave0. 

\subsection{Nave0}
\'E una classe di servizio. Ogni giocatore possiede due puntatori a oggetti di tipo Nave0, \_nave\_colpite e \_nave\_affondate; quando l'esito di uno sparo \'e "colpito", il giocatore che ha sparato assegna \_nave\_colpite al puntatore a nave della casella corrispondente, quando l'esito di uno sparo \'e "affondato" assegna \_nave\_affondate a tutte le caselle "colpite" adiacenti.

\subsection{Nave1, ..., Nave5}
Queste classi rappresentano le navi che un giocatore pu\'o inserire nel proprio mare. Hanno un metodo che ne ritorna la dimensione e assegnano "true" ad \_affondata quando subiscono un numero di colpi pari alla dimensione.

\section{Casella}
I tre attributi di questa classe sono due variabili booleane \_mia e \_sparata, e un puntatore a Nave \_nave\_qui; la variabile \_mia viene usata solamente nel metodo $<<$, per differenziare la stampa di caselle del proprio mare su cui sappiamo non esserci una nave, e caselle del mare avversario su cui dobbiamo ancora sparare; \_sparata dice se si \'e gi\'a sparato su quella casella; \_nave\_qui \'e nullo se non si sa se sulla casella sia posizionata una nave o se si sa che sulla casella non \'e posizionata una nave; punta alla nave corrispondente se sulla casella \'e posizionata una nave. La Casella non contiene l'informazione sullo stato della Nave (affondata o non affondata), che, per quanto riguarda \_mare\_mio \'e contenuta nella Nave che occupa la casella, per \_mare\_avv è contenuta nella navi di servizio della classe Nave0.



\end{document}
